package visiopuce.service;

import java.util.ArrayList;
import java.util.List;

import org.hibernate.HibernateException;

import visiopuce.ApplicationContexte;
import visiopuce.HibernateUtil;
import visiopuce.DAO.BandeDAO;
import visiopuce.DAO.BandeDAOImpl;
import visiopuce.DAO.BaseMicroremDAO;
import visiopuce.DAO.BaseMicroremDAOImpl;
import visiopuce.DAO.BiomedecineDAO;
import visiopuce.DAO.BiomedecineDAOImpl;
import visiopuce.DAO.CNPLyonDAO;
import visiopuce.DAO.CNPLyonDAOImpl;
import visiopuce.DAO.CNPOuestDAO;
import visiopuce.DAO.CNPOuestDAOImpl;
import visiopuce.DAO.CNPcDAO;
import visiopuce.DAO.CNPcDAOImpl;
import visiopuce.DAO.CategorieNonConformiteDAO;
import visiopuce.DAO.CategorieNonConformiteDAOImpl;
import visiopuce.DAO.Clone32kDAO;
import visiopuce.DAO.Clone32kDAOImpl;
import visiopuce.DAO.Clone4kDAO;
import visiopuce.DAO.Clone4kDAOImpl;
import visiopuce.DAO.CloneTilepathDAO;
import visiopuce.DAO.CloneTilepathDAOImpl;
import visiopuce.DAO.DGVVariantsDAO;
import visiopuce.DAO.DGVVariantsDAOImpl;
import visiopuce.DAO.GeneNcbiDAO;
import visiopuce.DAO.GeneNcbiDAOImpl;
import visiopuce.DAO.IscaDAO;
import visiopuce.DAO.IscaDAOImpl;
import visiopuce.DAO.MarquePuceDAO;
import visiopuce.DAO.MarquePuceDAOImpl;
import visiopuce.DAO.PhenotypeDAO;
import visiopuce.DAO.PhenotypeDAOImpl;
import visiopuce.DAO.ProbeDAO;
import visiopuce.DAO.ProbeDAOImpl;
import visiopuce.DAO.PuceDAOImpl;
import visiopuce.DAO.RedonDAO;
import visiopuce.DAO.RedonDAOImpl;
import visiopuce.DAO.SecteurDAO;
import visiopuce.DAO.SecteurDAOImpl;
import visiopuce.DAO.SiteFragileDAO;
import visiopuce.DAO.SiteFragileDAOImpl;
import visiopuce.DAO.SousCategorieNonConformiteDAO;
import visiopuce.DAO.SousCategorieNonConformiteDAOImpl;
import visiopuce.DAO.TailleChrDAO;
import visiopuce.DAO.TailleChrDAOImpl;
import visiopuce.DAO.TypeAnalyseDAO;
import visiopuce.DAO.TypeAnalyseDAOImpl;
import visiopuce.DAO.TypeCausalDAO;
import visiopuce.DAO.TypeCausalDAOImpl;
import visiopuce.DAO.TypeCotationDAO;
import visiopuce.DAO.TypeCotationDAOImpl;
import visiopuce.DAO.TypeLogicielDAO;
import visiopuce.DAO.TypeLogicielDAOImpl;
import visiopuce.DAO.TypeNonConformiteDAO;
import visiopuce.DAO.TypeNonConformiteDAOImpl;
import visiopuce.DAO.TypePlanExpDAO;
import visiopuce.DAO.TypePlanExpDAOImpl;
import visiopuce.DAO.TypePrelevementDAO;
import visiopuce.DAO.TypePrelevementDAOImpl;
import visiopuce.DAO.TypePuceDAO;
import visiopuce.DAO.TypePuceDAOImpl;
import visiopuce.DAO.TypeQCDAO;
import visiopuce.DAO.TypeQCDAOImpl;
import visiopuce.DAO.TypeRenduDAO;
import visiopuce.DAO.TypeRenduDAOImpl;
import visiopuce.objets.Alteration;
import visiopuce.objets.Bande;
import visiopuce.objets.BaseMicrorem;
import visiopuce.objets.Biomedecine;
import visiopuce.objets.CNPLyon;
import visiopuce.objets.CNPOuest;
import visiopuce.objets.CNPc;
import visiopuce.objets.CategorieNonConformite;
import visiopuce.objets.Clone32k;
import visiopuce.objets.Clone4k;
import visiopuce.objets.CloneTilepath;
import visiopuce.objets.DGVVariants;
import visiopuce.objets.GeneNcbi;
import visiopuce.objets.Isca;
import visiopuce.objets.MarquePuce;
import visiopuce.objets.Phenotype;
import visiopuce.objets.PrelevementSecteur;
import visiopuce.objets.Redon;
import visiopuce.objets.Secteur;
import visiopuce.objets.SiteFragile;
import visiopuce.objets.SousCategorieNonConformite;
import visiopuce.objets.TailleChr;
import visiopuce.objets.TypeAnalyse;
import visiopuce.objets.TypeCausal;
import visiopuce.objets.TypeCotation;
import visiopuce.objets.TypeLogiciel;
import visiopuce.objets.TypeNonConformite;
import visiopuce.objets.TypePlanExp;
import visiopuce.objets.TypePrelevement;
import visiopuce.objets.TypePuce;
import visiopuce.objets.TypeQC;
import visiopuce.objets.TypeRendu;

public class ReferentielServiceImpl implements ReferentielService {

	private TypePrelevementDAO typePrelevementDAO = TypePrelevementDAOImpl.getInstance();
	private TypeAnalyseDAO typeAnalyseDAO = TypeAnalyseDAOImpl.getInstance();
	private TypeLogicielDAO typeLogicielDAO = TypeLogicielDAOImpl.getInstance();
	private TypePlanExpDAO typePlanExpDAO = TypePlanExpDAOImpl.getInstance();
	private TypePuceDAO typePuceDAO = TypePuceDAOImpl.getInstance();
	private SecteurDAO secteurDAO = SecteurDAOImpl.getInstance();
	private TypeRenduDAO typeRenduDAO = TypeRenduDAOImpl.getInstance();
	private TypeCausalDAO typeCausalDAO = TypeCausalDAOImpl.getInstance();
	private PhenotypeDAO phenotypeDAO = PhenotypeDAOImpl.getInstance();
	private TypeCotationDAO typeCotationDAO = TypeCotationDAOImpl.getInstance();
	private TypeQCDAO typeQCDAO = TypeQCDAOImpl.getInstance();
	private BandeDAO bandeDAO = BandeDAOImpl.getInstance();
	private TailleChrDAO tailleChrDAO = TailleChrDAOImpl.getInstance();
	private BiomedecineDAO biomedecineDAO = BiomedecineDAOImpl.getInstance();
	private GeneNcbiDAO geneNcbiDAO = GeneNcbiDAOImpl.getInstance();
	private CNPOuestDAO cnpOuestDAO = CNPOuestDAOImpl.getInstance();
	private CNPLyonDAO cnpLyonDAO = CNPLyonDAOImpl.getInstance();
	private CNPcDAO cnpcDAO = CNPcDAOImpl.getInstance();
	private Clone4kDAO clone4kDAO = Clone4kDAOImpl.getInstance();
	private Clone32kDAO clone32kDAO = Clone32kDAOImpl.getInstance();
	private BaseMicroremDAO baseMicroremDAO = BaseMicroremDAOImpl.getInstance();
	private CloneTilepathDAO cloneTilepathDAO = CloneTilepathDAOImpl.getInstance();
	private SiteFragileDAO siteFragileDAO = SiteFragileDAOImpl.getInstance();
	private ProbeDAO probeDAO = ProbeDAOImpl.getInstance();
	// private MicroremDAO microRemDAO = MicroremDAOImpl.getInstance();
	private RedonDAO redonDAO = RedonDAOImpl.getInstance();
	private IscaDAO iscaDAO = IscaDAOImpl.getInstance();
	private DGVVariantsDAO dgvVariantsDAO = DGVVariantsDAOImpl.getInstance();
	private MarquePuceDAO marquePuceDAO = MarquePuceDAOImpl.getInstance();
	private TypeNonConformiteDAO typeNonConformiteDAO = TypeNonConformiteDAOImpl.getInstance();
	private CategorieNonConformiteDAO categorieNonConformiteDAOImpl = CategorieNonConformiteDAOImpl.getInstance();
	private SousCategorieNonConformiteDAO sousCategorieNonConformiteDAOImpl = SousCategorieNonConformiteDAOImpl.getInstance();

	/** Constructeur priv� */
	private ReferentielServiceImpl() {
	}

	/** Instance unique non pr�initialis�e */
	private static ReferentielServiceImpl INSTANCE = null;

	/** Point d'acc�s pour l'instance unique du singleton */
	public static ReferentielService getInstance() {
		if (INSTANCE == null) {
			INSTANCE = new ReferentielServiceImpl();
		}
		return INSTANCE;
	}

	@Override
	public ArrayList<TypePrelevement> getTypePrelevement() {
		ArrayList<TypePrelevement> prelevements = null;

		HibernateUtil.beginTransaction();
		prelevements = (ArrayList<TypePrelevement>) typePrelevementDAO.findAll(TypePrelevement.class);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();

		return prelevements;
	}

	@Override
	public Secteur getSecteurByNom(String nom) {
		HibernateUtil.beginTransaction();
		Secteur secteur = secteurDAO.findByNom(nom);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return secteur;
	}

	@Override
	public ArrayList<TypeAnalyse> getTypeAnalyse(Integer idAnalyse) {
		ArrayList<TypeAnalyse> typeAnalysesFinal = new ArrayList<TypeAnalyse>();
		ArrayList<TypeAnalyse> typeAnalyses = null;
		Secteur secteur = AnalyseServiceImpl.getInstance().getSecteurByIdAnalyse(idAnalyse);

		HibernateUtil.beginTransaction();
		typeAnalyses = (ArrayList<TypeAnalyse>) typeAnalyseDAO.findAll(TypeAnalyse.class);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		if (idAnalyse != null) {
			for (TypeAnalyse typeAnalyse : typeAnalyses) {

				if (idAnalyse != null && secteur.getLibelle().contains("Puce")) {
					if (typeAnalyse.getIdTypeAnalyse() == 3 || typeAnalyse.getIdTypeAnalyse() == 4 || typeAnalyse.getIdTypeAnalyse() == 2 || typeAnalyse.getIdTypeAnalyse() == 5 || typeAnalyse.getIdTypeAnalyse() == 6) {
						typeAnalysesFinal.add(typeAnalyse);
					}
				}
				// Prénat
				if (idAnalyse != null && secteur.getIdSecteur() == 1) {
					if (typeAnalyse.getIdTypeAnalyse() == 1 || typeAnalyse.getIdTypeAnalyse() == 2 || typeAnalyse.getIdTypeAnalyse() == 5 || typeAnalyse.getIdTypeAnalyse() == 6 || typeAnalyse.getIdTypeAnalyse() == 7) {
						typeAnalysesFinal.add(typeAnalyse);
					}
				}
				// Postnat
				if (idAnalyse != null && secteur.getIdSecteur() == 2) {
					if (typeAnalyse.getIdTypeAnalyse() == 1 || typeAnalyse.getIdTypeAnalyse() == 2) {
						typeAnalysesFinal.add(typeAnalyse);
					}
				}
				// foeto
				if (idAnalyse != null && secteur.getIdSecteur() == 4) {
					if (typeAnalyse.getIdTypeAnalyse() == 1 || typeAnalyse.getIdTypeAnalyse() == 2 || typeAnalyse.getIdTypeAnalyse() == 5 || typeAnalyse.getIdTypeAnalyse() == 6) {
						typeAnalysesFinal.add(typeAnalyse);
					}
				}
				if (idAnalyse != null && secteur.getIdSecteur() == 7) {
					typeAnalysesFinal.add(typeAnalyse);
				}
				if (idAnalyse == null)
					typeAnalysesFinal.add(typeAnalyse);
			}
		} else {
			typeAnalysesFinal = typeAnalyses;
		}

		return typeAnalysesFinal;
	}

	@Override
	public ArrayList<Biomedecine> getTypeIndication(String text) {
		ArrayList<Biomedecine> typeIndication = null;
		String secteur = "";
		if (text.equals(ApplicationContexte.SECTEUR_PRENATAL)) {
			secteur = "(6)";
		} else if (text.equals(ApplicationContexte.SECTEUR_POSTNATAL)) {
			secteur = "(5)";
		} else if (text.equals(ApplicationContexte.SECTEUR_PUCE_PRENATAL)) {
			secteur = "(1,4)";
		} else if (text.equals(ApplicationContexte.SECTEUR_PUCE_POSTNATAL)) {
			secteur = "(2)";
		} else if (text.equals(ApplicationContexte.SECTEUR_BANQUE)) {
			secteur = "(7)";
		} else if (text.equals(ApplicationContexte.SECTEUR_FOETO)) {
			secteur = "(5,6)";
		} else if (text.equals(ApplicationContexte.SECTEUR_PUCE_FOETO)) {
			secteur = "(3,4)";
		} else if (text.equals(ApplicationContexte.SECTEUR_CELLULES)) {
			secteur = "(8)";
		} else {
			secteur = null;
		}

		HibernateUtil.beginTransaction();
		typeIndication = (ArrayList<Biomedecine>) typeAnalyseDAO.getTypeIndicationByCategorie(secteur);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();

		return typeIndication;
	}

	@Override
	public ArrayList<TypeRendu> getTypeRendu(int nbStr) {
		ArrayList<TypeRendu> typeRendus = null;

		try {
			HibernateUtil.beginTransaction();
			typeRendus = typeRenduDAO.getTypeRenduByType(nbStr);
			HibernateUtil.commitTransaction();
			HibernateUtil.closeSession();
		} catch (HibernateException ex) {
			System.out.println("Erreur hibernate : ");
			ex.printStackTrace();
		}

		return typeRendus;
	}

	@Override
	public TypeRendu getTypeRenduById(int idTypeRendu) {
		TypeRendu typeRendu = null;

		try {
			HibernateUtil.beginTransaction();
			typeRendu = typeRenduDAO.findByID(TypeRendu.class, idTypeRendu);
			HibernateUtil.commitTransaction();
			HibernateUtil.closeSession();
		} catch (HibernateException ex) {
			System.out.println("Erreur hibernate : ");
			ex.printStackTrace();
		}

		return typeRendu;
	}

	@Override
	public ArrayList<TypePrelevement> getTypePrelevementBySecteur(String secteur) {
		ArrayList<TypePrelevement> prelevements = new ArrayList<TypePrelevement>();

		HibernateUtil.beginTransaction();
		List<PrelevementSecteur> prelevementSecteur = (List<PrelevementSecteur>) typePrelevementDAO.getTypePrelevementBySecteur(secteur);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		for (PrelevementSecteur prelevementSecteur2 : prelevementSecteur) {
			prelevements.add(prelevementSecteur2.getTypePrelevement());
		}

		return prelevements;
	}

	@Override
	public ArrayList<Phenotype> getPhentype(String libelle) {
		ArrayList<Phenotype> phenotypes = null;
		try {
			HibernateUtil.beginTransaction();
			phenotypes = phenotypeDAO.getPhenotype(libelle);
			HibernateUtil.commitTransaction();
			HibernateUtil.closeSession();
		} catch (HibernateException ex) {
			System.out.println("Erreur hibernate : ");
			ex.printStackTrace();
		}

		return phenotypes;
	}

	@Override
	public ArrayList<TypeCotation> getTypeCotation(String libelle) {
		ArrayList<TypeCotation> cotations = null;
		try {
			HibernateUtil.beginTransaction();
			cotations = typeCotationDAO.getTypeCotation(libelle);
			HibernateUtil.commitTransaction();
			HibernateUtil.closeSession();
		} catch (HibernateException ex) {
			System.out.println("Erreur hibernate : ");
			ex.printStackTrace();
		}

		return cotations;
	}

	@Override
	public Secteur getSecteurByid(String id) {
		HibernateUtil.beginTransaction();
		Secteur secteur = secteurDAO.findByID(Secteur.class, Integer.parseInt(id));
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return secteur;
	}

	@Override
	public TypeAnalyse getTypeAnalyseByid(String id) {
		HibernateUtil.beginTransaction();
		TypeAnalyse ta = typeAnalyseDAO.findByID(TypeAnalyse.class, Integer.parseInt(id));
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return ta;
	}

	@Override
	public TypePrelevement getTypePrelevementByLibelle(String typePrel) {
		if (typePrel.contains("Foetopathologie")) {
			typePrel = "Fibroblastes";
		}
		if (typePrel.contains("LA natif")) {
			typePrel = "Liquide Amniotique natif";
		}
		if (typePrel.contains("ulture de LA") || typePrel.contains("ulture LA")) {
			typePrel = "Culture de Liquide Amniotique";
		}
		if (typePrel.contains("Poumon")) {
			typePrel = "Fibroblastes";
		}
		if (typePrel.contains("ulture Fibroblastes")) {
			typePrel = "Fibroblastes";
		}
		if (typePrel.contains("ulture CVS")) {
			typePrel = "Culture de Villosités choriales";
		}

		HibernateUtil.beginTransaction();
		TypePrelevement ta = typePrelevementDAO.getTypePrelevementByLibelle(typePrel);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return ta;
	}

	@Override
	public long getTailleChromosome(String chromosome) {
		HibernateUtil.beginTransaction();
		TailleChr tc = tailleChrDAO.getTailleChromosome(chromosome);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return tc.getTailleHg19();
	}

	@Override
	public List<Bande> getBandesByChromosome(String chromosome) {
		ArrayList<Bande> bandes = null;
		try {
			HibernateUtil.beginTransaction();
			bandes = bandeDAO.getBandesByChromosome(chromosome);
			HibernateUtil.commitTransaction();
			HibernateUtil.closeSession();
		} catch (HibernateException ex) {
			System.out.println("Erreur hibernate : ");
			ex.printStackTrace();
		}

		return bandes;
	}

	@Override
	public TypePrelevement getTypePrelevementById(int idTP) {
		TypePrelevement u = null;
		HibernateUtil.beginTransaction();
		u = typePrelevementDAO.findByID(TypePrelevement.class, idTP);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return u;
	}

	@Override
	public Biomedecine getTypeIndicationById(int idBiomed) {
		Biomedecine u = null;
		HibernateUtil.beginTransaction();
		u = biomedecineDAO.findByID(Biomedecine.class, idBiomed);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return u;
	}

	@Override
	public TypePuce getTypePuceById(int idTP) {
		TypePuce u = null;
		HibernateUtil.beginTransaction();
		u = typePuceDAO.findByID(TypePuce.class, idTP);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return u;
	}

	@Override
	public TypeLogiciel getTypeLogicielById(int idTL) {
		TypeLogiciel u = null;
		HibernateUtil.beginTransaction();
		u = typeLogicielDAO.findByID(TypeLogiciel.class, idTL);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return u;
	}

	@Override
	public TypePlanExp getTypePlanExpByid(int idTypePlanExp) {
		TypePlanExp u = null;
		HibernateUtil.beginTransaction();
		u = typePlanExpDAO.findByID(TypePlanExp.class, idTypePlanExp);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return u;
	}

	@Override
	public ArrayList<GeneNcbi> getGeneNCBIByBorne(Alteration alteration, int seuil) {
		long tailleChr = ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
		ArrayList<GeneNcbi> list = new ArrayList<GeneNcbi>();
		HibernateUtil.beginTransaction();
		list = geneNcbiDAO.getGeneNCBIByBorne(alteration, tailleChr, seuil);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return list;
	}

	@Override
	public int getNbGeneNCBIByBorne(Alteration alteration, int seuil) {
		long tailleChr = ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
		int nbGene = 0;
		HibernateUtil.beginTransaction();
		nbGene = geneNcbiDAO.getNbGeneNCBIByBorne(alteration, tailleChr, seuil);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return nbGene;
	}

	@Override
	public List<CNPOuest> getCNPOuestByBorne(Alteration alteration, int seuil) {
		long tailleChr = ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
		ArrayList<CNPOuest> list = new ArrayList<CNPOuest>();
		HibernateUtil.beginTransaction();
		list = cnpOuestDAO.getCNPOuestByBorne(alteration, tailleChr, seuil);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return list;
	}

	@Override
	public List<CNPLyon> getCNPLyonByBorne(Alteration alteration, int seuil) {
		long tailleChr = ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
		ArrayList<CNPLyon> list = new ArrayList<CNPLyon>();
		HibernateUtil.beginTransaction();
		list = cnpLyonDAO.getCNPLyonByBorne(alteration, tailleChr, seuil);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return list;
	}

	@Override
	public List<Clone4k> getClone4kByBorne(Alteration alteration, int seuil) {
		long tailleChr = ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
		ArrayList<Clone4k> list = new ArrayList<Clone4k>();
		HibernateUtil.beginTransaction();
		list = clone4kDAO.getClone4kByBorne(alteration, tailleChr, seuil);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return list;
	}

	@Override
	public List<Clone32k> getClone32kByBorne(Alteration alteration, int seuil) {
		long tailleChr = ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
		ArrayList<Clone32k> list = new ArrayList<Clone32k>();
		HibernateUtil.beginTransaction();
		list = clone32kDAO.getClone32kByBorne(alteration, tailleChr, seuil);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return list;
	}

	@Override
	public List<CloneTilepath> getCloneTilepathByBorne(Alteration alteration, int seuil) {
		long tailleChr = ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
		ArrayList<CloneTilepath> list = new ArrayList<CloneTilepath>();
		HibernateUtil.beginTransaction();
		list = cloneTilepathDAO.getCloneTilepathByBorne(alteration, tailleChr, seuil);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return list;
	}

	@Override
	public List<CNPc> getCNPcByBorne(Alteration alteration, int seuil) {
		long tailleChr = ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
		ArrayList<CNPc> list = new ArrayList<CNPc>();
		HibernateUtil.beginTransaction();
		list = cnpcDAO.getCNPcByBorne(alteration, tailleChr, seuil);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return list;
	}

	@Override
	public List<Redon> getRedonByBorne(Alteration alteration, int seuil) {
		long tailleChr = ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
		ArrayList<Redon> list = new ArrayList<Redon>();
		HibernateUtil.beginTransaction();
		list = redonDAO.getRedonByBorne(alteration, tailleChr, seuil);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return list;
	}

	@Override
	public List<Isca> getIscaByBorne(Alteration alteration, int seuil) {
		long tailleChr = ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
		ArrayList<Isca> list = new ArrayList<Isca>();
		HibernateUtil.beginTransaction();
		list = iscaDAO.getIscaByBorne(alteration, tailleChr, seuil);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return list;
	}

	@Override
	public List<SiteFragile> getSiteFragileByBorne(Alteration alteration, int seuil) {
		long tailleChr = ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
		ArrayList<SiteFragile> list = new ArrayList<SiteFragile>();
		HibernateUtil.beginTransaction();
		list = siteFragileDAO.getSiteFragileByBorne(alteration, tailleChr, seuil);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return list;
	}

	@Override
	public long[] getBornesByBande(String chromosome, String bande) {
		long[] tabl = new long[2];
		HibernateUtil.beginTransaction();
		Bande b = bandeDAO.getBornesByBande(chromosome, bande);
		HibernateUtil.commitTransaction();
		tabl[1] = b.getFinHg19();
		tabl[0] = b.getDebutHg19();
		return tabl;

	}

	//
	// @Override
	// public List<Microrem> getMicroRemByBorne(Alteration alteration) {
	// int tailleChr =
	// ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
	// ArrayList<Microrem> list = new ArrayList<Microrem>();
	// HibernateUtil.beginTransaction();
	// list = microRemDAO.getMicroremByBorne(alteration, tailleChr);
	// HibernateUtil.commitTransaction();
	// return list;
	// }

	@Override
	public List<BaseMicrorem> getBaseMicroremByBorne(Alteration alteration, int seuil) {
		long tailleChr = ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
		ArrayList<BaseMicrorem> list = new ArrayList<BaseMicrorem>();
		HibernateUtil.beginTransaction();
		list = baseMicroremDAO.getBaseMicroremByBorne(alteration, tailleChr, seuil);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return list;
	}

	@Override
	public List<GeneNcbi> getImprintingByBorne(Alteration alteration, int seuil) {
		long tailleChr = ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
		ArrayList<GeneNcbi> list = new ArrayList<GeneNcbi>();
		HibernateUtil.beginTransaction();
		list = geneNcbiDAO.getImprintingByBorne(alteration, tailleChr, seuil);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return list;
	}

	@Override
	public List<DGVVariants> getDGVVariantsByBorne(Alteration alteration, int seuil) {
		long tailleChr = ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
		ArrayList<DGVVariants> list = new ArrayList<DGVVariants>();
		HibernateUtil.beginTransaction();
		list = dgvVariantsDAO.getDGVVariantsByBorne(alteration, tailleChr, seuil);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return list;
	}

	@Override
	public List getProbeByBorne(Alteration alteration, int seuil) {
		long tailleChr = ReferentielServiceImpl.getInstance().getTailleChromosome(alteration.getChromosome());
		HibernateUtil.beginTransaction();
		TypePuce tp = PuceDAOImpl.getInstance().getTypePuceByIdPuce(alteration.getPuce().getIdPuce());

		ArrayList list = new ArrayList();
		if (tp != null) {
			list = probeDAO.getProbeByBorne(alteration, tailleChr, tp, seuil);
		}
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return list;
	}

	@Override
	public ArrayList<TypeCausal> getTypeCausals() {
		ArrayList<TypeCausal> typeCausals = null;

		try {
			HibernateUtil.beginTransaction();
			typeCausals = (ArrayList<TypeCausal>) typeCausalDAO.findAll(TypeCausal.class);
			HibernateUtil.commitTransaction();
			HibernateUtil.closeSession();
		} catch (HibernateException ex) {
			System.out.println("Erreur hibernate : ");
			ex.printStackTrace();
		}

		return typeCausals;

	}

	@Override
	public List<TypePuce> getTypePuceByMarquePuce(MarquePuce marquePuceSel) {
		ArrayList<TypePuce> typePuces = new ArrayList<TypePuce>();

		HibernateUtil.beginTransaction();
		typePuces = typePuceDAO.getTypePuceByMarquePuce(marquePuceSel);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();

		return typePuces;
	}

	@Override
	public List<TypeQC> getTypeQCByTypePuce(TypePuce typePuce) {
		ArrayList<TypeQC> typeQCs = new ArrayList<TypeQC>();

		HibernateUtil.beginTransaction();
		typeQCs = typeQCDAO.getTypeQCByTypePuce(typePuce);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();

		return typeQCs;
	}

	@Override
	public ArrayList<MarquePuce> getMarquePuce() {
		ArrayList<MarquePuce> prelevements = null;

		HibernateUtil.beginTransaction();
		prelevements = (ArrayList<MarquePuce>) marquePuceDAO.findAll(MarquePuce.class);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();

		return prelevements;
	}

	@Override
	public List<Bande> getBandesByCNV(Alteration alt) {
		ArrayList<Bande> bandes = null;
		try {
			HibernateUtil.beginTransaction();
			bandes = bandeDAO.getBandesByCNV(alt);
			HibernateUtil.commitTransaction();
			HibernateUtil.closeSession();
		} catch (HibernateException ex) {
			System.out.println("Erreur hibernate : ");
			ex.printStackTrace();
		}

		return bandes;
	}

	@Override
	public ArrayList<TypeLogiciel> getTypeLogiciels() {
		ArrayList<TypeLogiciel> typelog = null;

		HibernateUtil.beginTransaction();
		typelog = (ArrayList<TypeLogiciel>) typeLogicielDAO.findAll(TypeLogiciel.class);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();

		return typelog;
	}

	@Override
	public Phenotype getPhentypeById(int idPheno) {
		Phenotype pheno = null;
		HibernateUtil.beginTransaction();
		pheno = phenotypeDAO.findByID(Phenotype.class, idPheno);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();

		return pheno;
	}

	@Override
	public ArrayList<TypeAnalyse> getTypeAnalyseByPrelevement(Integer idPrelevement) {
		ArrayList<TypeAnalyse> typeAnalysesFinal = new ArrayList<TypeAnalyse>();
		ArrayList<TypeAnalyse> typeAnalyses = null;
		Secteur secteur = PrelevementServiceImpl.getInstance().getSecteurByIdPrelevement(idPrelevement);

		HibernateUtil.beginTransaction();
		typeAnalyses = (ArrayList<TypeAnalyse>) typeAnalyseDAO.findAll(TypeAnalyse.class);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		if (idPrelevement != null) {
			for (TypeAnalyse typeAnalyse : typeAnalyses) {

				if (idPrelevement != null && secteur.getLibelle().contains("Puce")) {
					if (typeAnalyse.getIdTypeAnalyse() == 3 || typeAnalyse.getIdTypeAnalyse() == 4 || typeAnalyse.getIdTypeAnalyse() == 2 || typeAnalyse.getIdTypeAnalyse() == 5 || typeAnalyse.getIdTypeAnalyse() == 6) {
						typeAnalysesFinal.add(typeAnalyse);
					}
				}
				// Prénat
				if (idPrelevement != null && secteur.getIdSecteur() == 1) {
					if (typeAnalyse.getIdTypeAnalyse() == 1 || typeAnalyse.getIdTypeAnalyse() == 8 || typeAnalyse.getIdTypeAnalyse() == 5 || typeAnalyse.getIdTypeAnalyse() == 6 || typeAnalyse.getIdTypeAnalyse() == 7) {
						typeAnalysesFinal.add(typeAnalyse);
					}
				}
				// Postnat
				if (idPrelevement != null && secteur.getIdSecteur() == 2) {
					if (typeAnalyse.getIdTypeAnalyse() == 1 || typeAnalyse.getIdTypeAnalyse() == 8) {
						typeAnalysesFinal.add(typeAnalyse);
					}
				}
				// foeto
				if (idPrelevement != null && secteur.getIdSecteur() == 4) {
					if (typeAnalyse.getIdTypeAnalyse() == 1 || typeAnalyse.getIdTypeAnalyse() == 8 || typeAnalyse.getIdTypeAnalyse() == 5 || typeAnalyse.getIdTypeAnalyse() == 6) {
						typeAnalysesFinal.add(typeAnalyse);
					}
				}
				if (idPrelevement != null && secteur.getIdSecteur() == 7) {
					typeAnalysesFinal.add(typeAnalyse);
				}
				if (idPrelevement == null)
					typeAnalysesFinal.add(typeAnalyse);
			}
		}

		return typeAnalysesFinal;
	}

	@Override
	public String getProbeByAlteration(String chr, Long position, int idTypePuce) {
		String probe = "";
		HibernateUtil.beginTransaction();
		probe = probeDAO.getProbeByAlteration(chr, position, idTypePuce);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();

		return probe;
	}

	@Override
	public ArrayList<TypePlanExp> getTypePlanExp() {
		ArrayList<TypePlanExp> typeplanExp = null;

		HibernateUtil.beginTransaction();
		typeplanExp = (ArrayList<TypePlanExp>) typePlanExpDAO.findAll(TypePlanExp.class);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();

		return typeplanExp;
	}

	@Override
	public GeneNcbi getGeneNCBIBySymbol(String symbol) {
		HibernateUtil.beginTransaction();
		GeneNcbi gene = geneNcbiDAO.getGeneNCBIBySymbol(symbol);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return gene;
	}

	@Override
	public Biomedecine getTypeIndicationByLibelle(String libelle) {
		Biomedecine biomedecine = null;
		HibernateUtil.beginTransaction();
		biomedecine = biomedecineDAO.getBiomedecineByLibelle(libelle);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();

		return biomedecine;
	}

	@Override
	public String[] getCotationFromString(String text) {

		HibernateUtil.beginTransaction();
		List<TypeCotation> cotations = TypeCotationDAOImpl.getInstance().getTypeCotationByTxt(text);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();

		String[] cots = new String[cotations.size()];
		int i = 0;
		for (TypeCotation typeCotation : cotations) {
			cots[i] = typeCotation.getLibelle() + "-" + typeCotation.getDescription();
			i++;
		}

		return cots;
	}

	@Override
	public TypeCotation getTypeCotationByLibelle(String libelle) {
		List<TypeCotation> types = getTypeCotation(libelle);
		if (types.size() > 0) {
			return types.get(0);
		}
		return null;
	}

	@Override
	public Biomedecine getTypeIndicationByLibelleAndCategorie(String biomed, int catbiomed) {
		Biomedecine biomedecine = null;
		HibernateUtil.beginTransaction();
		biomedecine = biomedecineDAO.getTypeIndicationByLibelleAndCategorie(biomed, catbiomed);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();

		return biomedecine;
	}

	@Override
	public ArrayList<Bande> getBandes() {
		ArrayList<Bande> bandes = null;
		HibernateUtil.beginTransaction();
		bandes = (ArrayList<Bande>) bandeDAO.findAll(Bande.class);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return bandes;
	}

	@Override
	public ArrayList<GeneNcbi> getGenesNCBI() {
		ArrayList<GeneNcbi> genes = null;
		HibernateUtil.beginTransaction();
		genes = (ArrayList<GeneNcbi>) geneNcbiDAO.findAll(GeneNcbi.class);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return genes;
	}

	@Override
	public TypeQC getTypeQCByTypePuceAndLibelle(TypePuce typePuce, String typeQCs) {
		TypeQC typeQC = null;

		HibernateUtil.beginTransaction();
		typeQC = typeQCDAO.getTypeQCByTypePuceAndLibelle(typePuce, typeQCs);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();

		return typeQC;

	}

	@Override
	public ArrayList<TypeNonConformite> getTypeNonConformite() {
		ArrayList<TypeNonConformite> types = null;
		HibernateUtil.beginTransaction();
		types = (ArrayList<TypeNonConformite>) typeNonConformiteDAO.findAll(TypeNonConformite.class);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return types;
	}

	@Override
	public ArrayList<CategorieNonConformite> getCategorieNonConfByIdTypeNonConformite(int idTypeNonConf) {
		ArrayList<CategorieNonConformite> types = null;
		HibernateUtil.beginTransaction();
		types = (ArrayList<CategorieNonConformite>) categorieNonConformiteDAOImpl.getCategorieNonConfByIdTypeNonConformite(idTypeNonConf);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return types;
	}

	@Override
	public ArrayList<SousCategorieNonConformite> getSousCategorieNonConfByIdCategorieNonConformite(int idTypeNonConf) {
		ArrayList<SousCategorieNonConformite> types = null;
		HibernateUtil.beginTransaction();
		types = (ArrayList<SousCategorieNonConformite>) sousCategorieNonConformiteDAOImpl.getSousCategorieNonConfByIdCategorieNonConformite(idTypeNonConf);
		HibernateUtil.commitTransaction();
		HibernateUtil.closeSession();
		return types;
	}
}
